/**
 * 数据提取
 * @param {Array<object>} arr
 * @param {Array||string} key
 */
import { isArray, isObject } from './typeUitl'
import * as XLSX from 'xlsx'

export function getData(arr, key, isKey) {
    let keys = []
    if (!isArray(arr)) {
        console.error('Error: %s (%i)', '格式错误,当前getData的arr数据必须为数组')
        return []
    }
    isArray(key) ? (keys = key) : keys.push(key)
    return arr.map(item => {
        if (isKey) {
            const obj = {}
            keys.forEach(e => {
                obj[e] = item[e]
            })
            return obj
        } else {
            // @ts-ignore
            return item[keys]
        }
    })
}

export function arrChangeObj(arr, key, value) {
    let obj = {}
    if (arr) {
        arr.forEach(item => {
            obj[item.key] = item[value]
        })
    }
    return obj
}

/**
 * 树数组修改值
 * @param tree
 * @param key
 * @param childrenKey
 * @returns {*}
 * @constructor
 */
export function TreeUpate(tree, key = {}, childrenKey = 'children') {
    tree.forEach(item => {
        for (const i in key) {
            item[key[i]] = item[i]
        }
        if (item[childrenKey] && item[childrenKey].length > 0) {
            TreeUpate(item[childrenKey], key, childrenKey)
        }
    })
    return tree
}

/**
 * 数据更改
 * @param {Array<object>} arr
 * @param {Array||string} key
 */
export function upData(arr, obj) {
    if (!isArray(arr)) {
        console.error('Error: %s (%i)', '格式错误,当前upData的arr数据必须为数组')
        return []
    }
    return arr.map(item => {
        for (let i in obj) {
            item[obj[i]] = item[i]
        }
        return item
    })
}

/**
 * 根据值获取相关参数
 * @param {Array<Object>} arr  数据集
 * @param {string} key         参数名
 * @param {any} value          值
 * @param {boolean} isIndex    返回值是否是下标
 * @param {boolean} is        true为值相等，false为不等
 */
export function ExtractData(arr, key, value, isIndex, is = true) {
    let arrs = isIndex ? '' : []
    let arrs1 = isIndex ? '' : []
    if (!isArray(arr)) {
        console.error('Error: %s (%i)', '格式错误,当前upData的arr数据必须为数组')
        return []
    }
    arr.forEach((item, index) => {
        if (item[key] == value) {
            if (isIndex) {
                arrs = index
            } else {
                if (typeof arrs !== 'string') {
                    arrs.push(item)
                }
            }
        } else {
            if (isIndex) {
                arrs = index
            } else {
                if (typeof arrs1 !== 'string') {
                    arrs1.push(item)
                }
            }
        }
    })
    return is ? arrs : arrs1
}

/**
 * 树形数据
 * @param arr           数据
 * @param childrenKey   children默认children
 * @param childrenName  子级参数Name 默认children
 * @param key           对比参数key 默认id
 * @param value         对比值
 * @param is            相等 默认true
 * @returns {[]}        返回值
 * @constructor
 */
export function TreeDataGetData(
    arr = [],
    childrenKey = 'children',
    key = 'id',
    value,
    is = true,
    returnArr
) {
    arr.forEach(item => {
        if (item[key] == value && is) {
            returnArr.push(item)
        } else if (item[key] != value && is == false) {
            returnArr.push(item)
        }
        if (isArray(item[childrenKey]) && item[childrenKey].length > 0) {
            TreeDataGetData(item[childrenKey], childrenKey, key, value, is, returnArr)
        }
    })
    return returnArr
}

/**
 * 数组对象去重
 * @param {Array<Object>} data 数据源
 * @param {*} key 根据唯一值参数默认id
 */
export function ArrayClearRepeat(data, key = 'id') {
    let hash = {}
    return data.reduce((item, next) => {
        hash[next[key]] ? '' : (hash[next[key]] = true && item.push(next))
        return item
    }, [])
}

export function openUrl(url, view) {
    view.location = url
}

/**
 * 数组对象中查询是否存在某个值
 * @param arr
 * @param key
 * @param value
 * @returns {*[]}
 * @constructor
 */
export function ArrIsValue(arr, key = 'id', value) {
    if (!isArray(arr)) {
        console.error('Error: %s (%i)', '格式错误,当前upData的arr数据必须为数组')
        return []
    }
    return arr.filter(item => item[key] === value).length > 0 ? true : false
}

export function JsonChangeStr(str) {
    return JSON.stringify(str).replace(/\"/g, '')
}

export function analyticalData(file, colWidth, fn) {
    // 通过FileReader对象读取文件
    let columns = [],
        data = []
    const fileReader = new FileReader()
    fileReader.readAsBinaryString(file)
    fileReader.onload = e => {
        const { result } = e.target
        // 以二进制流方式读取得到整份excel表格对象
        const workbook = XLSX.read(result, { type: 'binary' })
        const xlsxSource = XLSX.utils.sheet_to_json(workbook.Sheets.Sheet1)
        xlsxSource.forEach((item, index) => {
            // 第一个列为列名所以筛选掉
            if (index > 0) {
                data.push(item)
            } else {
                for (let i in item) {
                    columns.push({
                        title: item[i],
                        dataIndex: i,
                        key: i,
                        width: colWidth || 150,
                    })
                }
            }
        })
        fn && fn({ columns, data })
    }
}

export function isArrayObj(arr, arr2) {
    let status = true
    if (arr.length === arr2.length) {
        if (JSON.stringify(arr) != JSON.stringify(arr2)) {
            status = false
        }
    } else {
        status = false
    }
    return status
}

/**
 * 去除空格
 * @param str
 * @returns {*}
 */
export function strClearSpace(str) {
    return str.replace(/\s+/g, '')
}

/**
 * 数据转化
 * @param limit
 * @returns {string}
 */
export function sizeChange(limit) {
    var size = ''
    if (limit < 0.1 * 1024) {
        //如果小于0.1KB转化成B
        size = limit.toFixed(2) + 'B'
    } else if (limit < 0.1 * 1024 * 1024) {
        //如果小于0.1MB转化成KB
        size = (limit / 1024).toFixed(2) + 'KB'
    } else if (limit < 0.1 * 1024 * 1024 * 1024) {
        //如果小于0.1GB转化成MB
        size = (limit / (1024 * 1024)).toFixed(2) + 'MB'
    } else {
        //其他转化成GB
        size = (limit / (1024 * 1024 * 1024)).toFixed(2) + 'GB'
    }

    var sizestr = size + ''
    var len = sizestr.indexOf('.')
    var dec = sizestr.substr(len + 1, 2)
    if (dec == '00') {
        //当小数点后为00时 去掉小数部分
        return sizestr.substring(0, len) + sizestr.substr(len + 3, 2)
    }
    return sizestr
}

/**
 * 数据转化
 * @param data
 * @param changeObj
 */
export function dataChange(data, changeObj) {
    let source
    if (isArray(data)) {
        source = data.map(item => {
            let obj = item
            for (const i in changeObj) {
                obj[changeObj[i]] = obj[i]
            }
            return obj
        })
        return source
    } else if (isObject) {
        source = data
        for (const i in changeObj) {
            source[changeObj[i]] = source[i]
        }
        return source
    } else {
        console.log(`当前数据对象类型非对象或者数据对象：${data}`)
        return data
    }
}

export default getData
